In particular, for process reasons it may be desirable or necessary that two or more robots take up pre-set positions at the same time, for example, to handle together a workpiece, in particular to process it, or to pass it to each other.
In this context, FIG. 1 shows an internally known principle of a corresponding synchronization between two robots, described by their revolute coordinates q1 and q2. In this case, starting from a previous position q1(Ti), the slower robot 1 moves at the maximum speed or acceleration to a subsequent predetermined position q1(T(i+1)). This yields the required traversing time ΔT=T(i+1)−Ti. For the two robots to take up the synchronized positions q1(T(i+1)) and q2(T(i+1)) at a point in time, either the faster robot can be moved slower in the traversing time, i.e., can be moved without exploiting its maximum speed or acceleration (FIG. 1A)—here its speed is derived from the difference q2(Ti+1))−q2(Ti) and the traversing time ΔT required for the slower robot—or from its own maximum speed or acceleration and the remaining time spent waiting for the slower robot (FIG. 1B). This procedure can be successively repeated in order to synchronize a plurality of successive positions during a movement.
Based on this section-wise, forward-moving approach, the so far known programming means for programming synchronized movements necessarily provides for a strictly 1:1 bijective assignment of positions of the robots: every given position of a movement of a robot must be associated with a position of the movement of the other robot.
If, for instance, a further position is to be specified between two synchronized positions of a robot, such as to avoid collision, one must therefore also accordingly program for the other robot an actually unnecessary—dummy—position and synchronize it with the latter. This is not only complicated and error-prone, but it also unnecessarily restricts the flexibility of the other robot, such as the possibility to vary its movement for optimization.